Disclaimer: Fuente del logo e imágenes de cargo son propiedad de The Cargo Book

En esta publicación vamos a aprender a instalar Rust y vamos a hablar también de algo muy importante en si quieres ser un programador profesional en Rust llamado Cargo.

Sin mas preámbulos, empecemos a instalar Rust.

Instalación de Rust.

Instalar Rust es un proceso bastante simple, sin embargo, debes tomar en cuenta el sistema operativo que estas utilizando, vamos a echarles un vistazo a los siguientes sistemas operativos (sin orden de preferencia).

Instalación en Windows.

Si tu sistema operativo es Windows, entonces dirígete a:

https://www.rust-lang.org/tools/install

Como muchas cosas en Windows encontrarás un archivo de instalación, solamente debes dar siguiente hasta tener todo instalado.

Instalación en Mac.

Para instalar Rust en mac, debes tener curl instalado, si no lo has instalado puedes hacerlo con brew, ejecuta en un terminal el siguiente comando:

brew install curl

Con curl instalado, si ingresas a https://www.rust-lang.org/tools/install, verás la opción recomendada es instalar Rust con el siguiente comando.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Si todo sale bien deberías de ver un mensaje similar al siguiente:

Rust is installed now. Great!

Instalación en Linux.

La instalación en linux es prácticamente igual a la instalación en Mac, en una terminal y con curl instalado, debes ejecutar:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

y verás el mismo resultado

Rust is installed now. Great!

Verificando si la instalación ha sido exitosa.

Una vez instalado, siempre es bueno verificar que la instalación ha sido exitosa, algo a tomar en cuenta es que Rust, por defecto no se agrega al PATH del sistema operativo, por lo que deberás agregarlo dependiendo de tu versión de sistema operativo.

Para agregar Rust al PATH, los instaladores instalarán todos los binarios dentro de la carpeta ~/.cargo/bin/ (Si te encuentras en Windows el símbolo ~ hace referencia al home o carpeta de tu usuario). Agrega la carpeta mencionada al PATH de tu sistema operativo.

Ahora en una terminal puedes ejecutar el siguiente comando:

rustc --version 

Si la instalación a sido correcta, verás desplegarse en la terminal un mensaje como el siguiente:

rustc 1.60.0 (7737e0b5c 2022-04-04)

La versión puede variar dependiendo del último release que Rust haya publicado.

Haciendo un "hello world" con Rust.

Otra forma de verificar si todo ha quedado bien instalado es realizar un "hello world", empecemos nuestro primer programa con Rust 😎

En algún folder que quieras, crea un archivo y colócale por nombre main.rs (la extensión rs hace referencia a que es el código fuente de un archivo en Rust), luego en mi caso yo lo crearé en la carpeta ~/hello/, por lo que la ruta completa de mi archivo es: ~/hello/main.rs

Dentro del archivo main.rs escribe el siguiente código:

        
        
            // main.rs

fn main() {
  println!("Hello World!");
}
        
        
    

Rust es un lenguaje en el cual para ejecutar nuestro código debemos compilarlo, y para ello necesitamos un "compilador". Cuando instalas rust, dentro de los binarios, viene incluido por lo que no es necesario instalar nada nuevo.

En una terminal, en la misma carpeta donde creaste el archivo main.rs (en mi caso ~/hello/), debes ejecutar el siguiente comando:

rustc main.rs

Si Rust está bien instalado, deberás ver que el comando finaliza sin ningún mensaje. Si te llegase a aparecer algún mensaje, deberás revisar si tu instalación ha sido exitosa.

El comando anterior le indica al compilador de Rust, que debe traducir a lenguaje entendido por las máquinas y deberá crearte un archivo sin ninguna extensión de nombre "main", al explorar tu carpeta debes de ver estos dos archivos:

Ahora, siempre en la terminal debes ejecutar el siguiente comando ./main

Si tu programa ha funcionado deberás de ver el siguiente output en tu consola.

Si te sale el mismo output, te felicito, tu instalación fue exitosa y creaste tu primer programa en Rust! 🥳

Hablemos de Cargo.

En el ejemplo anterior creamos nuestro primer programa con Rust, pero para ser honestos, fue un proyecto bastante simple a comparación de los proyectos que desarrollamos día con día ya sea en un ambiente laboral, educativo o personal.

Para proyectos muchos más complejos, muchas veces necesitaremos utilizar librerías o paquetes pre fabricados que contienen muchas funcionalidades que facilitan nuestro trabajo, en Rust, estos paquetes reciben el nombre de crates.

También es probable que queramos organizar nuestro código en distintos folders y crear un único archivo compilado a partir de nuestro organizada estructura de carpetas. Todos los casos anteriores pueden ser manejados por el compilador, pero se puede volver bastante complicado coordinar todas esas acciones. Para facilitar todo esto podemos utilizar Cargo, el cual es el gestor de paquetes de Rust (y hace muchas cosas más 😃).

Rust es un binario que se instalará de forma automática cuando instalamos Rust, si no me crees, en una terminal, ejecuta el siguiente comando:

cargo --version

Podrás ver que en tu terminal te mostrará la versión de Cargo que tienes instalado.

Empecemos a utilizar Cargo repitiendo el mismo hello world del ejemplo anterior, pero ahora de una forma un poco más organizada.

En una terminal, en la carpeta de tu preferencia, en mi caso la carpeta será ~/proyectos, ejecuta el siguiente comando:

cargo new hello-cargo

Si todo sale bien, verás que en tu terminal te mostrará el siguiente mensaje:

Created binary (application) `hello-cargo` package

también verás que dentro de la carpeta que elegiste, en mi caso ~/proyectos, cargo habrá creado una nueva carpeta llamada hello-cargo

muévete a hello-cargo y exploremos que es lo que ha sido creado en esta nueva carpeta, deberías de ver los siguientes archivos.

Como puedes observar a creado una carpeta src dentro de la cual hay un archivo main.rs (te suena familiar?)

También podrás observar que ha creado un archivo .gitignore, quiere decir que de una vez, Cargo ha creado un proyecto con con control de versiones en git por nosotros.

Y por último veremos un archivo llamado Cargo.toml, vamos a hablar un poco más en detalle sobre este archivo.

El archivo Cargo.toml, es el equivalente al archivo manifest de Rust, el cual se escribe con la notación TOML

Si abres el archivo Cargo.toml vemos que ha creado el siguiente manifest.

        
        
            // Cargo.toml

[package]
name = "hello-cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

        
        
    

La primera parte está dentro de una sección denotada por [package] dentro del cual vemos la metadata sobre el proyecto que Cargo creó por nosotros, estos proyectos son considerados como librerías o crates por Rust.

Por ejemplo el name, es el nombre de nuestro proyecto o crate, no recomendamos cambiar este dato una vez creado el proyecto. El campo version hace referencia la versión del crate y puedes editarlo de acuerdo a la versión semántica que estás utilizando, en nuestro caso no lo cambiaremos, por último es la edición de Rust que estamos usando, tampoco recomendamos carmbiarlo.

Luego encontrarás un enlace para más definiciones o keys que se pueden incluir en el archivo Cargo.toml:

https://doc.rust-lang.org/cargo/reference/manifest.html

Al final encontraremos una sección llamada [dependencies], bajo el cual, estaremos colocando los crates o librerías auxiliares de nuestro proyecto, por el momento no agregaremos ninguna.

Ahora que hemos dado un vistazo general, vamos a repetir el programa de hello world, dentro de la carpeta src, abre el archivo main.rs y coloca el mismo código anterior:

        
        
            // src/main.rs

fn main() {
  println!("Hello World!");
}
        
        
    

Antes, compilamos el programa utilizando rustc directamente, pero ahora lo haremos utilizando Cargo y de una vez le pediremos que lo ejecute por nosotros, para ello ejecuta el siguiente comando en una terminal dentro de la carpeta principal de tu proyecto, en mi caso ~/proyectos/hello-cargo (no te metas a src dentro de hello-cargo para este comando).

cargo run

Si todo sale bien, cargo compilará y ejecutará el programa al mismo tiempo, si todo sale bien deberías de ver el mismo mensaje "Hello World" en tu terminal.

Parece que cargo ha compilado y ejecutado todo por nosotros, pero ¿dónde están los archivos ejecutables?

Si vemos nuevamente la estructura de carpetas, veremos que cargo ha creado una nueva carpeta llamada target

Dentro de la carpeta target ha creado una carpeta llamada debug, dentro de la cual podrás encontrar el archivo ejecutable.

Cargo realiza muchas tareas por nosotros como la generación de este ejecutable, nuevamente nuestro programa es bastante sencillo, pero si nuestro código está distribuido en varias carpetas, se encargará de organizar todo por nosotros y generará siempre el mismo ejecutable. sin embargo, NO recomiendo distribuir un ejecutable en modo Debug.

En la siguiente parte de esta publicación, veremos cómo crear un ejecutable que SI te recomiendo crear y cómo manejar el tema de paquetes externos y cómo manejarlos con Cargo para que puedan ser incluidos en nuestro ejecutable. Si esta publicación te ha sido de utilidad, compártela con tus amigos o en tus redes sociales 😄

Puedes encontrar el código fuente de nuestro ejemplo dando click a este enlace:

println!("Hasta la Próxima")!